package com.xidian.zhiancloud.controller.checkdanger;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.EasyExcelFactory;
import com.alibaba.excel.metadata.Sheet;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.github.pagehelper.Page;
import com.xidian.zhiancloud.controller.base.BaseController;
import com.xidian.zhiancloud.dto.ResultDTO;
import com.xidian.zhiancloud.enums.GeneralResponseEnums;
import com.xidian.zhiancloud.enums.UserResponseEnums;
import com.xidian.zhiancloud.model.checkdanger.ChkAcceptData;
import com.xidian.zhiancloud.model.checkdanger.ChkCheckData;
import com.xidian.zhiancloud.model.checkdanger.ChkModifyData;
import com.xidian.zhiancloud.model.checkdanger.ChkRData;
import com.xidian.zhiancloud.qo.BaseReqQuery;
import com.xidian.zhiancloud.service.checkdanger.ChkRecordService;

@RestController
@RequestMapping("/chkrd")
public class ChkRecordController extends BaseController{

    @Autowired
    ChkRecordService chkrdService;

    /**
     *  -隐患上报列表

     * @param reqdata
     * @param key     搜索关键字
     * @return 返回 ResultDTO 对象
     * @return (t_danger_chk_risktype)，pointname 风险点(隐患排查清单列表)，
     * 排查项目（隐患排查清单列表 里面的 排查项目字段，没有的话就是其他
     * 基础管理类    排查项目
     * 设备设施类    检查项目
     * 作业活动类    作业步骤
     * 工艺节点类    节点名称
     * ），risktpname 隐患类别（隐患类别设置 列表  t_danger_chk_tpset）
     * ，positionname 隐患地点(sys_position)，，
     *
     * status 状态（1未提交，2未判定，3已判定，4核查中，5整改中，6验收中，7已完成）
     * judagestatus 判定结果（1未提交，2未判定，3不是隐患，4是隐患）
     *
     *  --已判定，就会到 隐患核查列表
     *
     * -- 列表
     * --typename 风险点类型，pointname 风险点，name 隐患名称，remark 隐患描述，createtime 上报时间，addname 上报人，status 状态，judagestatus 判定结果
     * --departname 隐患责任部门，positionname 隐患地点，imgpath 隐患整改前照片，judagename 判定人
     */
    @SuppressWarnings("rawtypes")
    @RequestMapping(value = "/getChkRecordList")
    public ResultDTO getChkRecordList(BaseReqQuery reqdata,
                                      @RequestParam(value="key",required=false ,defaultValue="") String key)
    {
        Page<Map<String,String>> pagedata = chkrdService.getChkRecordList(reqdata,key);
        Map<String, Object> data = new HashMap<String, Object>();
		data.put("datalist", pagedata);
		data.put("PageNum", pagedata.getPageNum());
		data.put("PageSize", pagedata.getPageSize());
		data.put("PageTotal", pagedata.getPages());
		data.put("total", pagedata.getTotal());
        return ResultDTO.successOf(data, GeneralResponseEnums.SUCCESS);
    }
    /**
     *  - 登记隐患
     *  dangertypeid 风险点类型，dangerpointid 风险点，name 隐患名称，remark 隐患描述，
     *  -departid 隐患责任部门，positionid 隐患地点,imgpath 隐患整改前照片，judageuserid 判定人
     */
    @RequestMapping(value = "/insertChkRecord")
    public ResultDTO insertChkRecord(ChkRData rddata)
    {
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("dangertypeid", rddata.getDangertypeid());
        in.put("dangerpointid", rddata.getDangerpointid());
        in.put("positionid", rddata.getPositionid());

        in.put("name", rddata.getName());
        in.put("remark", rddata.getRemark());
        in.put("departid", rddata.getDepartid());
        in.put("imgpath", rddata.getImgpath());
        in.put("judageuserid", rddata.getJudageuserid());
        in.put("status", 1);//rddata.getStatus());
        in.put("judagestatus", rddata.getJudagestatus());
        in.put("dangerpointype", 1);
        in.put("userid", this.getSessionUserid());
        int rd = chkrdService.insertChkRecord(in);
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }

    /**
     * -提交
     * status =1
     * -删除
     * status =0
     * -编辑
     *    --
     * - 判定
     *  //tysetid 隐患类别，
     *  judageresult（1，是隐患，2，不是隐患） 判定结果
     */
    @RequestMapping(value = "/updateChkRecord")
    public ResultDTO updateChkRecord(ChkRData rddata)
    {
    	if(rddata.getId()<=0)
        	return ResultDTO.errorOf(UserResponseEnums.USER_PARAMETERS_ERROR);
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("id", rddata.getId());
        if(rddata.getCmd()==1) // 提交
        {
            in.put("status", 2);
        }
        else if(rddata.getCmd()==2) // 删除
        {
            in.put("status", "0");
        }
        else if(rddata.getCmd()==3) // 编辑
        {
            in.put("id", rddata.getId());
            in.put("dangertypeid", rddata.getDangertypeid());
            in.put("dangerpointid", rddata.getDangerpointid());
            in.put("name", rddata.getName());
            in.put("remark", rddata.getRemark());
            in.put("departid", rddata.getDepartid());
            in.put("imgpath", rddata.getImgpath());
            in.put("judageuserid", rddata.getJudageuserid());
            in.put("judagestatus", rddata.getJudagestatus());
            in.put("tysetid", rddata.getTysetid());
        }
        else  // 判定  增加核查人
        {
            in.put("judageuserid", rddata.getJudageuserid());
            
            in.put("judageresult", rddata.getJudageresult());
            in.put("judagestatus", rddata.getJudagestatus());
            in.put("tysetid", rddata.getTysetid());
            if(rddata.getJudageresult()==1) // 是隐患
            {
            	in.put("status", 4); //  核查中
            }
            else
            	in.put("status", 3);  // 已判定
            // 增加 核查人  chkuserid  chkrdid =id
            ChkCheckData chkdata = new ChkCheckData();
            chkdata.setChkuserid(rddata.getChkuserid());
            chkdata.setChkrdid(rddata.getId());
            ResultDTO rd = insertChkCheck(chkdata);
        }
        chkrdService.updateChkRecord(in);

        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }


    /**
     *  -隐患核查列表

     * @param reqdata
     * @param key     搜索关键字
     * @return 返回 ResultDTO 对象
     *
     * rdname 隐患名称，隐患级别，finishdate 核查时间，attachpath 隐患整改通知单(自动生成)，状态（已核查）
     *
     *-- 隐患核查结果   （1  不是隐患，  2 一般隐患  ，3 重大隐患。 4 上报隐患）
     *
     * departname 整改部门  
     *
     *-- 整改类型 （1 立即整改， 2，限期整改， 3 停产停业整改）
     *
     *-- 已核查， 进入整改列表
     *
     *-- 列表
     *   -pointname 风险点，typename 风险点类型，rdname 隐患名称，chklevelid隐患级别，attachpath 隐患整改通知单
     *   status 状态 （1 待核查， 2，已核查），updatetime 核查时间
     */
    @SuppressWarnings("rawtypes")
    @RequestMapping(value = "/getChkCheckList")
    public ResultDTO getChkCheckList(BaseReqQuery reqdata,
                                     @RequestParam(value="key",required=false ,defaultValue="") String key)
    {
        Page<Map<String,String>> pagedata = chkrdService.getChkCheckList(reqdata,key);
        Map<String, Object> data = new HashMap<String, Object>();
		data.put("datalist", pagedata);
		data.put("PageNum", pagedata.getPageNum());
		data.put("PageSize", pagedata.getPageSize());
		data.put("PageTotal", pagedata.getPages());
		data.put("total", pagedata.getTotal());
        return ResultDTO.successOf(data, GeneralResponseEnums.SUCCESS);
    }

    @RequestMapping(value = "/insertChkCheck")
    public ResultDTO insertChkCheck(ChkCheckData chkdata)
    {
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("chkuserid", chkdata.getChkuserid());
        in.put("chkrdid", chkdata.getChkrdid());
        in.put("status", 1);
        chkrdService.insertChkCheck(in);
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }
    /**
     *  -隐患整改列表 核查列表里面的核查按钮

     * @param ChkCheckData
     * -- 核查
     *  -advise 隐患核查意见，chklevelid 隐患核查结果   （1  不是隐患，  2 一般隐患  ，3 重大隐患。 4 上报隐患），scheme 隐患治理措施，departid隐患整改部门，
     *      --  liableuserid  隐患整改责任人，modifytype 隐患整改类型，finishdate 完成期限，attachpath 附件
     */
    @RequestMapping(value = "/updateChkCheck")
    public ResultDTO updateChkCheck(ChkCheckData chkdata)
    {
    	if(chkdata.getId()<=0||chkdata.getChkrdid()<=0)
        	return ResultDTO.errorOf(UserResponseEnums.USER_PARAMETERS_ERROR);
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("id", chkdata.getId());
        in.put("advise", chkdata.getAdvise());
        in.put("chklevelid", chkdata.getChklevelid());
        in.put("scheme", chkdata.getScheme());
        in.put("departid", chkdata.getDepartid());
        in.put("liableuserid", chkdata.getLiableuserid());
        in.put("modifytype", chkdata.getModifytype());
        in.put("finishdate", chkdata.getFinishdate());
        in.put("attachpath", chkdata.getAttachpath());
        in.put("status", 2);
        chkrdService.updateChkCheck(in);

        Map<String,Object> rd = new HashMap<String, Object>();
        rd.put("id", chkdata.getChkrdid());
        rd.put("status", 5);  //整改中
        chkrdService.updateChkRecord(in);
        ChkModifyData mdata = new ChkModifyData();
        mdata.setRectifyuserid(chkdata.getLiableuserid());
        mdata.setCheckid(chkdata.getId());
        mdata.setChkrdid(chkdata.getChkrdid());
        mdata.setStatus(1);
        insertChkModify(mdata);
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }

    /**
     *  -隐患整改列表 

     * @param reqdata
     * @param key     搜索关键字
     * @return 返回 ResultDTO 对象
     * -- 列表
     * -pointname风险点，typename 风险点类型，rdname 隐患名称，chklevelid 隐患级别，finishdate 整改期限，rectifyusername 整改人，rectify_pic 隐患整改通知单，status 状态(1 待整改, 2 已整改)
     *
     * -已整改，，进入验收列表
     */
    @SuppressWarnings("rawtypes")
    @RequestMapping(value = "/getChkModifyList")
    public ResultDTO getChkModifyList(BaseReqQuery reqdata,
                                      @RequestParam(value="key",required=false ,defaultValue="") String key)
    {
        Page<Map<String,String>> pagedata = chkrdService.getChkModifyList(reqdata,key);
        Map<String, Object> data = new HashMap<String, Object>();
		data.put("datalist", pagedata);
		data.put("PageNum", pagedata.getPageNum());
		data.put("PageSize", pagedata.getPageSize());
		data.put("PageTotal", pagedata.getPages());
		data.put("total", pagedata.getTotal());
        return ResultDTO.successOf(data, GeneralResponseEnums.SUCCESS);
    }

    @RequestMapping(value = "/insertChkModify")
    public ResultDTO insertChkModify(ChkModifyData mdata)
    {
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("rectifyuserid", mdata.getRectifyuserid());
        in.put("checkid", mdata.getCheckid());
        in.put("chkrdid", mdata.getChkrdid());
        in.put("status", mdata.getStatus());
        chkrdService.insertChkModify(in);
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }

    /**
     *--整改 
     *  -scheme 隐患整改措施，situation隐患整改情况，money隐患整改资金，finishdate 整改完成时间，chkuserid 验收负责人，rectify_pic 整改后照片
     */
    @RequestMapping(value = "/updateChkModify")
    public ResultDTO updateChkModify(ChkModifyData mdata)
    {
    	if(mdata.getId()<=0||mdata.getChkrdid()<=0)
        	return ResultDTO.errorOf(UserResponseEnums.USER_PARAMETERS_ERROR);
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("id", mdata.getId());
        in.put("scheme", mdata.getScheme());
        in.put("situation", mdata.getSituation());
        in.put("money", mdata.getMoney());
        in.put("finishdate", mdata.getFinishdate());
        in.put("chkuserid", mdata.getChkuserid());
        in.put("rectify_pic", mdata.getRectify_pic());
        in.put("status", 2);
        chkrdService.updateChkModify(in);
        
        Map<String,Object> rd = new HashMap<String, Object>();
        rd.put("id", mdata.getChkrdid());
        rd.put("status", 6);  //验收中
        chkrdService.updateChkRecord(rd);
        
        if(mdata.getStatus()==3)
        {
        	Map<String,Object> ssin = new HashMap<String, Object>();
        	ssin.put("chkrdid", mdata.getChkrdid());
        	ssin.put("status",0);
        	chkrdService.updateChkAccept(ssin);
        	
        }
        ChkAcceptData adata = new ChkAcceptData();
        adata.setAcceptuserid(mdata.getChkuserid());
        adata.setModifyid(mdata.getId());
        adata.setChkrdid(mdata.getChkrdid());
        adata.setStatus(1);
        insertChkAccept(adata);
        
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }

    /**
     *  -隐患验收列表

     * @param reqdata
     * @param key     搜索关键字
     * @return 返回 ResultDTO 对象
     * --pointname 风险点，typename 风险点类型，rdname 隐患名称，chklevelid 隐患级别，updatetime 验收时间，acceptusername 验收人，status 状态
     *
     * -验收结果   （1 通过， 2 不通过）
     * - 不通过，进入 整改记录
     */
    @SuppressWarnings("rawtypes")
    @RequestMapping(value = "/getChkAcceptList")
    public ResultDTO getChkAcceptList(BaseReqQuery reqdata,
                                      @RequestParam(value="key",required=false ,defaultValue="") String key)
    {
        Page<Map<String,String>> pagedata = chkrdService.getChkAcceptList(reqdata,key);
        Map<String, Object> data = new HashMap<String, Object>();
		data.put("datalist", pagedata);
		data.put("PageNum", pagedata.getPageNum());
		data.put("PageSize", pagedata.getPageSize());
		data.put("PageTotal", pagedata.getPages());
		data.put("total", pagedata.getTotal());
        return ResultDTO.successOf(data, GeneralResponseEnums.SUCCESS);
    }

    @RequestMapping(value = "/insertChkAccept")
    public ResultDTO insertChkAccept(ChkAcceptData adata)
    {
        Map<String,Object> in = new HashMap<String, Object>();
        in.put("acceptuserid", adata.getAcceptuserid());
        in.put("modifyid", adata.getModifyid());
        in.put("chkrdid", adata.getChkrdid());
        in.put("status",adata.getStatus());
        chkrdService.insertChkAccept(in);
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }
    /**
     *  -验收
     *   - advise 验收意见，result验收结果（1 通过， 2 不通过），acceptdoc 验收文件
     *
     */
    @RequestMapping(value = "/updateChkAccept")
    public ResultDTO updateChkAccept(ChkAcceptData adata)
    {
        Map<String,Object> in = new HashMap<String, Object>();
        if(adata.getId()<=0||adata.getChkrdid()<=0)
        	return ResultDTO.errorOf(UserResponseEnums.USER_PARAMETERS_ERROR);
        in.put("id", adata.getId());
        in.put("chkrdid", adata.getChkrdid());
        
        in.put("advise", adata.getAdvise());
        in.put("result",adata.getResult());
        in.put("acceptdoc",adata.getAcceptdoc());
        in.put("status",2);
        chkrdService.updateChkAccept(in);
        
        
        Map<String,Object> rd = new HashMap<String, Object>();
        rd.put("rd", adata.getChkrdid());
        rd.put("status", 7);  //验收中
        if(adata.getResult() == 2)
        {
        	Map<String,Object> rm = new HashMap<String, Object>();
            rm.put("chkrdid", adata.getChkrdid());
            rm.put("status", 3);
            chkrdService.updateChkModify(rm);
            
            //  设置 验收列表，状态为不通过
            Map<String,Object> ssin = new HashMap<String, Object>();
        	ssin.put("id", adata.getId());
        	ssin.put("status",3);
        	chkrdService.updateChkAccept(ssin);
        }
        
        
        return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
    }
   
    /*
     * *
     *  --  获取记录详细   cmd  1 上报详细， 2， 上报详细+ 核查详细  3 上报详细+ 核查详细 + 整改详细
     *  -- 4 上报详细+ 核查详细 + 整改详细 + 验收详细   rdid  上报 记录ID
     */
    @RequestMapping(value = "/getRDDeail")
    public ResultDTO getRDDeail(int cmd,String rdid)
    {
    	Map<String,Object> out = new HashMap<String, Object>();
    	if(cmd == 1)
    	{
    		Map<String, String> deail = chkrdService.getRDDeail1(rdid);
    		out.put("data1", deail);
    	}
    	if(cmd == 2)
    	{
    		Map<String, String> deail = chkrdService.getRDDeail1(rdid);
    		out.put("data1", deail);
    		Map<String, String> deail2 = chkrdService.getRDCheck2(rdid);
    		out.put("data2", deail2);
    	}
    	if(cmd == 3)
    	{
    		Map<String, String> deail = chkrdService.getRDDeail1(rdid);
    		out.put("data1", deail);
    		Map<String, String> deail2 = chkrdService.getRDCheck2(rdid);
    		out.put("data2", deail2);
    		Map<String, String> deail3 = chkrdService.getRDModify3(rdid);
    		out.put("data3", deail3);
    		
    	}
    	if(cmd == 4)
    	{
    		Map<String, String> deail = chkrdService.getRDDeail1(rdid);
    		out.put("data1", deail);
    		Map<String, String> deail2 = chkrdService.getRDCheck2(rdid);
    		out.put("data2", deail2);
    		Map<String, String> deail3 = chkrdService.getRDModify3(rdid);
    		out.put("data3", deail3);
    		Map<String, String> deail4 = chkrdService.getRDAccept4(rdid);
    		out.put("data4", deail4);
    	}
    	return ResultDTO.successOf(out, GeneralResponseEnums.SUCCESS);
    }
    
    @RequestMapping("/ImportExcelFile")
	public ResultDTO ImportExcelFile(@RequestParam("file") MultipartFile file) throws IOException{
		
		ExcelReadListener excelistener = new ExcelReadListener();
		//excelistener.userservice = userservice;
		String sfile = "E:\\logs\\1605519537140_571.xlsx";
		
		
	
		EasyExcel.read(file.getInputStream(),  excelistener).sheet(0).doRead();
		
		return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
	}
    
    @SuppressWarnings("deprecation")
	@RequestMapping("/ImportExcel")
   	public ResultDTO ImportExcel() throws IOException{
   		
   		//excelistener.userservice = userservice;
   		String sfile = "E:\\logs\\22223.xlsx";
   		
   		try {
            // sheetNo --> 读取哪一个 表单
            // headLineMun --> 从哪一行开始读取( 不包括定义的这一行，比如 headLineMun为2 ，那么取出来的数据是从 第三行的数据开始读取 )
            // clazz --> 将读取的数据，转化成对应的实体，需要 extends BaseRowModel
            Sheet sheet = new Sheet(1, 1);

            ReadSheet readSheet = EasyExcel.readSheet(0).build();
            // 这里 取出来的是 ExcelModel实体 的集合
            List<Object> readList = EasyExcelFactory.read(new FileInputStream(sfile), sheet);
            
            //List<Object> readList1 = EasyExcelFactory.read(new FileInputStream(sfile), readSheet);
            
            List<Map> listMap = EasyExcel.read(sfile).sheet().doReadSync();
            for (Map data : listMap) {
            	// 返回每条数据的键值对 表示所在的列 和所在列的值

            	// LOGGER.info("读取到数据:{}", JSON.toJSONString(data));

            }
            
            List<Object> list = EasyExcel.read(sfile).sheet(0).doReadSync();
            for (Object obj : list) {
                // 返回每条数据的键值对 表示所在的列 和所在列的值
                Map<Integer, String> data = (Map<Integer, String>)obj;
                //LOGGER.info("读取到数据:{}", JSON.toJSONString(data));
            }
            // 存 ExcelMode 实体的 集合
            /*List<ExcelMode> list = new ArrayList<ExcelMode>();
            for (Object obj : readList) {
                list.add((ExcelMode) obj);
            }

            // 取出数据
            StringBuilder str = new StringBuilder();
            str.append("{");
            String link = "";
            for (ExcelMode mode : list) {
                str.append(link).append("\""+mode.getColumn1()+"\":").append("\""+mode.getColumn2()+"\"");
                link= ",";
            }
            str.append("};");
            System.out.println(str);*/

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
   		
   		return ResultDTO.successOf(null, GeneralResponseEnums.SUCCESS);
   	}
}
